home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Games / Arashi 1.1 / Game Source / jam src / GridTest.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-14  |  9.4 KB  |  447 lines  |  [TEXT/KAHL]
  1. /*/
  2.      Project Arashi: GridTest.c
  3.      Major release: Version 1.1, 7/22/92
  4.  
  5.      Last modification: Sunday, March 14, 1993, 23:16
  6.      Created: Thursday, February 9, 1989, 22:32
  7.  
  8.      Copyright © 1989-1993, Juri Munkki
  9. /*/
  10.  
  11. #include <Math.h>
  12. #include "VA.h"
  13. #define    _MAKEGRID_
  14. #include "STORM.h"
  15. #include "heroflags.h"
  16.  
  17. #define PI 3.1415926535
  18.  
  19. #define    FIELDADVANCE    8
  20. #define    FIELDSTART        (2*DEPTH)
  21.  
  22. extern    Player    Hero;
  23.  
  24. int        xcen;
  25. int        ycen;
  26.  
  27. int        FieldDistance;
  28.  
  29. #define    DOSTARRIDE
  30.  
  31. extern    int        StarsUsed;
  32. extern    Point    NewStarTwist;
  33.  
  34. void    FieldRide(
  35.     worldstruct    *world,
  36.     short        fieldAdvance)
  37. {
  38.     int        i;
  39.     int        x[MAXSEGS],y[MAXSEGS];
  40.     int        xb[MAXSEGS],yb[MAXSEGS];
  41.     
  42.     if(!VA.Late)
  43.     {    VA.color=0;
  44.         if(FieldDistance<STARTDEPTH*2)
  45.                 VA.color=0;
  46.         else    VA.color=(FieldDistance-STARTDEPTH)*7/(FIELDSTART-STARTDEPTH-1);
  47.         
  48.         if(VA.color > 6) VA.color = 6;
  49.  
  50.         for(i=0;i<=ww.numsegs;i++)
  51.         {    x[i]=((world->x[i]-world->xoff)*STARTDEPTH)
  52.                     /(long)(STARTDEPTH+FieldDistance)+xcen+world->xoff;
  53.             y[i]=((world->y[i]-world->yoff)*STARTDEPTH)
  54.                     /(long)(STARTDEPTH+FieldDistance)+ycen+world->yoff;
  55.             xb[i]=((world->x[i]-world->xoff)*STARTDEPTH)
  56.                     /(long)(STARTDEPTH+DEPTH+FieldDistance)+xcen+world->xoff;
  57.             yb[i]=((world->y[i]-world->yoff)*STARTDEPTH)
  58.                     /(long)(STARTDEPTH+DEPTH+FieldDistance)+ycen+world->yoff;
  59.             
  60.             VAMoveTo(x[i],y[i]);
  61.             VASafeLineTo(xb[i],yb[i]);
  62.         }
  63.         VAMoveTo(x[0],y[0]);
  64.         for(i=1;i<=ww.numsegs;i++)
  65.         {    VASafeLineTo(x[i],y[i]);
  66.         }
  67.     
  68.         VAMoveTo(xb[0],yb[0]);
  69.         for(i=1;i<=ww.numsegs;i++)
  70.         {    VASafeLineTo(xb[i],yb[i]);
  71.         }
  72.     }
  73.     
  74.     FieldDistance += fieldAdvance;
  75.     if(FieldDistance<0)    FieldDistance=0;
  76. }
  77. void    StarStep()
  78. {
  79. #ifdef    DOSTARRIDE
  80. #ifdef BACKGROUND_FRIENDLY
  81.         GameEvent();
  82. #endif
  83.         FeedStars();
  84.         RideStars();
  85.         VAStep();
  86. #endif
  87. }
  88. void    StarsOut()
  89. {
  90. #ifdef DOSTARRIDE
  91.     if(StarsUsed)        
  92.     {    RideStars();
  93.     }
  94. #endif
  95. }
  96.  
  97. void DoZapRecharge(onoff)
  98. int onoff;
  99. {
  100.     /* This next section will add the message             */
  101.     /* "Superzapper recharge" to the screen (mz)        */
  102.     
  103.     unsigned char    *text=(void *)"\pSuperzapper Recharge";
  104.     int                x,y;
  105.     
  106.     if(Hero.Flags & ShowSuperZapMsgMask)
  107.     {
  108.         VA.segmscale = (int)(Getfontscale() * 1.5);
  109.         if(VA.segmscale <=1) 
  110.             VA.segmscale=2;
  111.         x = (int)( (VA.frame.right - 20*(VA.segmscale*3 + 3))/2 );
  112.         y = (int)(VA.frame.bottom - 2);
  113.         VAMoveTo(x,y);
  114.         VA.color=BG1;
  115.         if (!onoff)                    /* Erase option */
  116.             VA.color = -1;        
  117.         VADrawText((char *)text,1,20);
  118.     }
  119. }
  120.  
  121. void    MakeSpots(world)
  122. worldstruct    *world;
  123. {
  124.     register    int        d,i,j;
  125.  
  126.     ww.numsegs=world->numsegs;
  127.     ww.wraps=world->wraps;
  128.  
  129.     for(d=ZOOMDEPTH;d<=DEPTH;d++)
  130.     {    for(i=0;i<=ww.numsegs;i++)
  131.         {    ww.x[i][d]=((world->x[i]-world->xoff)*(long)STARTDEPTH)
  132.                             /(STARTDEPTH+d)+xcen+world->xoff;
  133.             ww.y[i][d]=((world->y[i]-world->yoff)*(long)STARTDEPTH)
  134.                             /(STARTDEPTH+d)+ycen+world->yoff;
  135.         }
  136.         ww.unitlen[d]=(world->unitlen * (long)STARTDEPTH) / (STARTDEPTH+d);
  137.         if(!(d & 31))
  138.             StarStep();
  139.     }
  140.  
  141.  
  142.     for(d=ZOOMDEPTH+1;d<DEPTH+1;d++)
  143.     {    for(i=0;i<ww.numsegs;i++)
  144.         {    ww.xc[i][d]=(ww.x[i][d]+ww.x[i+1][d])>>1;
  145.             ww.yc[i][d]=(ww.y[i][d]+ww.y[i+1][d])>>1;
  146.         }
  147.         if(!(d & 15))
  148.         {    StarsOut();
  149.             if(StarsUsed)
  150.             {    VAStep();
  151. #ifdef BACKGROUND_FRIENDLY
  152.                 GameEvent();
  153. #endif
  154.             }
  155.         }
  156.     }
  157.  
  158.     FieldDistance=FIELDSTART; 
  159.  
  160.     /*    Precalculate paths for spinning stars at center of playfield:    */
  161.     ww.starsegs=ww.numsegs*STARDIVISION;
  162.     for(d=0;d<2;d++)
  163.     {    for(i=0;i<=ww.numsegs;i++)
  164.         {    ww.starx[i*STARDIVISION][d]=((world->x[i]-world->xoff)*(long)STARTDEPTH)
  165.                             /(STARTDEPTH+DEPTH+(DEPTH*2)*d)+xcen+world->xoff;
  166.             ww.stary[i*STARDIVISION][d]=((world->y[i]-world->yoff)*(long)STARTDEPTH)
  167.                             /(STARTDEPTH+DEPTH+(DEPTH*2)*d)+ycen+world->yoff;
  168.         }
  169.         for(i=0;i<ww.starsegs;i+=STARDIVISION)
  170.         {    for(j=1;j<STARDIVISION;j++)
  171.             {    ww.starx[i+j][d]=(ww.starx[i+STARDIVISION][d]-ww.starx[i][d])*j/STARDIVISION+
  172.                                   ww.starx[i][d];
  173.                 ww.stary[i+j][d]=(ww.stary[i+STARDIVISION][d]-ww.stary[i][d])*j/STARDIVISION+
  174.                                   ww.stary[i][d];
  175.             }
  176.             if(FieldDistance)
  177.             {    FieldRide(world,-FIELDADVANCE);
  178.                 StarsOut();
  179. #ifdef BACKGROUND_FRIENDLY
  180.                 GameEvent();
  181. #endif
  182.                 VAStep();
  183.             }
  184.         }
  185.     }
  186.  
  187.     if(FieldDistance)
  188.     {    while(FieldDistance)
  189.         {    FieldRide(world,-FIELDADVANCE);
  190. #ifdef BACKGROUND_FRIENDLY
  191.             GameEvent();
  192. #endif
  193.             VAStep();
  194.         }
  195.         
  196.         VA.Late=0;
  197.     }
  198.     FieldRide(world,-FIELDADVANCE);
  199.     VAStep();
  200.  
  201.     {    int        mode;
  202.         
  203.         mode=QD32COMPATIBLE;
  204.         SwapMMUMode(&mode);
  205.     
  206.         VA.field=1;        VA.offset=1;        VA.color=0;
  207.     
  208.         for(i=0;i<ww.numsegs;i++)
  209.         {    VABresenham(ww.x[i][0],ww.y[i][0],ww.x[i][DEPTH],ww.y[i][DEPTH]);
  210.         }
  211.         if(ww.wraps==0)
  212.             VABresenham(ww.x[i][0],ww.y[i][0],ww.x[i][DEPTH],ww.y[i][DEPTH]);
  213.         
  214.         for(d=0;d<=DEPTH;d+=DEPTH)
  215.         {    for(i=0;i<ww.numsegs;i++)
  216.             {    VABresenham(ww.x[i][d],ww.y[i][d],ww.x[i+1][d],ww.y[i+1][d]);
  217.             }
  218.         }
  219.         VA.field=3;
  220.         SwapMMUMode(&mode);
  221.     }
  222.     VAStep();
  223.     VASetColors(GetResource('CLOT',ThisLevel.lvColor));
  224.     VACatchUp();
  225.  
  226. }
  227.  
  228. void    CreateFit()
  229. {
  230.  
  231.     register    double    x,y,sx,sy;
  232.     register    int        i,j,k;
  233.     register    shape    *space;
  234.                 double    xmin,xmax,ymin,ymax,a;
  235.     register    shape    **spacehand;
  236.  
  237.     double        AngularConstant= PI * 2.0 / ANGLES;
  238.  
  239.  
  240.     if (ThisLevel.lvColor != 5)            /* Use alternate grey for invis levels (mz) */
  241.         OpenStars(GetResource('CLOT',ThisLevel.lvColor));
  242.     else
  243.         OpenStars(GetResource('CLOT',ThisLevel.lvColor + 128));
  244.  
  245.     VA.segmscale=(VA.frame.bottom>>6);
  246.     if(VA.segmscale<1) VA.segmscale=1;
  247.     k=VA.color;
  248.     VA.color=BG2;
  249.     if (ThisLevel.lvColor == 5)        /* check for invis BG2 on ivis waves (mz) */
  250.         VA.color=BG1;
  251.     VADrawNumber(ThisLevel.lvNumber,VA.frame.right/2-VA.segmscale-3,VA.segmscale*2+4);
  252.     VA.color=k;
  253.         
  254.     DoZapRecharge(1);                /* (mz) */
  255.  
  256.     spacehand=(void *)GetResource('SPCE',ThisLevel.lvField);
  257.     HLock(spacehand);
  258.     space=*spacehand;
  259.     
  260.     gridOutline.numsegs=space->numsegs;
  261.     if(gridOutline.numsegs>=MAXSEGS-1) DebugStr("\PToo many shape segments error");
  262.     xmin=xmax=ymin=ymax=x=y=0.0;
  263.     a=0.0;
  264.     
  265.     for(i=0;i<space->numsegs;i++)
  266.     {    double    TempAngle;
  267.     
  268.         a+=space->ang[i];
  269.         TempAngle=a*AngularConstant;
  270.         x+= cos(TempAngle);
  271.         y-= sin(TempAngle);
  272.         if(x<xmin)    xmin=x;
  273.         else
  274.         if(x>xmax)    xmax=x;
  275.         if(y<ymin)    ymin=y;
  276.         else
  277.         if(y>ymax)    ymax=y;
  278.         
  279.         StarStep();
  280.     }
  281.  
  282. #ifdef TWIST_CONTROL
  283.     {    /*    Change margins to account for twist.    */
  284.     
  285.         double    xshift,yshift,normalmargin;
  286.         double    twist,midpoint;
  287.  
  288.         xshift = space->xoff/6.0;
  289.         yshift = space->yoff/6.0;
  290.         
  291.         midpoint = (xmax+xmin)/2;
  292.     
  293.         twist = (xmax - xshift) * (long)STARTDEPTH / (DEPTH+STARTDEPTH) + xshift;
  294.         if(twist > xmax)        xmax = twist;
  295.     
  296.         twist = (xmin - xshift) * (long)STARTDEPTH / (DEPTH+STARTDEPTH) + xshift;
  297.         if(twist < xmin)        xmin = twist;
  298.     
  299.         midpoint = (ymax+ymin)/2;
  300.  
  301.         twist = (ymax - yshift) * (long)STARTDEPTH / (DEPTH+STARTDEPTH) + yshift;
  302.         if(twist > ymax)        ymax = twist;
  303.     
  304.         twist = (ymin - yshift) * (long)STARTDEPTH / (DEPTH+STARTDEPTH) + yshift;
  305.         if(twist < ymin)        ymin = twist;
  306.     
  307.         normalmargin = 1.2;
  308.         xmin -= normalmargin;
  309.         ymin -= normalmargin;
  310.         xmax += normalmargin;
  311.         ymax += normalmargin;
  312.     }
  313. #else
  314.     {    double normalmargin;
  315.  
  316.         normalmargin = 1.2;
  317.         xmin -= normalmargin;
  318.         ymin -= normalmargin;
  319.         xmax += normalmargin;
  320.         ymax += normalmargin;
  321.     }
  322. #endif
  323.     x = -(xmin+xmax)/2;
  324.     y = -(ymin+ymax)/2;
  325.     
  326.     xcen=(VA.frame.right+VA.frame.left)/2;
  327.     ycen=(VA.frame.bottom+VA.frame.top)/2;
  328.     
  329.     sx=(VA.frame.right-VA.frame.left)/(xmax-xmin);
  330.     sy=(VA.frame.bottom-VA.frame.top)/(ymax-ymin);
  331.     if(sy<sx)    sx=sy;
  332.  
  333. #ifdef TWIST_CONTROL
  334. #define    TWIST_DIVIDE    8
  335. #else
  336. #define    TWIST_DIVIDE    32
  337. #endif
  338.     gridOutline.xoff=space->xoff*sx/TWIST_DIVIDE;
  339.     gridOutline.yoff=space->yoff*sx/TWIST_DIVIDE;
  340.  
  341.     NewStarTwist.h=gridOutline.xoff;
  342.     NewStarTwist.v=gridOutline.yoff;
  343.     
  344.     gridOutline.unitlen= sx;
  345.     x= sx * x + 0.5;
  346.     y= sx * y + 0.5;
  347.     a=0.0;
  348.     for(i=0;i<space->numsegs;i++)
  349.     {    double    TempAngle;
  350.     
  351.         a+=space->ang[i];
  352.         TempAngle=a*AngularConstant;
  353.  
  354.         gridOutline.x[i]=x;
  355.         gridOutline.y[i]=y;
  356.         
  357.         x+= cos(TempAngle)*sx;
  358.         y-= sin(TempAngle)*sx;
  359.         
  360.         StarStep();
  361.     }
  362.         
  363.     gridOutline.x[i]=x;
  364.     gridOutline.y[i]=y;
  365.     gridOutline.wraps=space->wraps;
  366.     if(space->wraps)
  367.     {    gridOutline.x[i]=gridOutline.x[0];
  368.         gridOutline.y[i]=gridOutline.y[0];
  369.     }
  370.  
  371.     j=0;
  372.     for(i=0;i<space->numsegs;i++)
  373.     {    j+=space->ang[i];
  374.         NextSeg[i]=(j+4*ANGLES) % ANGLES;
  375.     }
  376.     NextSeg[i]=NextSeg[0];
  377.  
  378.     for(i=0;i<=space->numsegs;i++)
  379.     {    PrevSeg[i]=(ANGLES/2+NextSeg[(i-1+space->numsegs) % space->numsegs]) % ANGLES;
  380.     }
  381.     
  382.     for(i=0;i<=space->numsegs;i++)
  383.     {    k=(NextSeg[i]+PrevSeg[i])/2;
  384.         if(NextSeg[i]<k) k+=ANGLES/2;
  385.  
  386.         for(j=k;j<k+ANGLES/2;j++)
  387.             LaneSel[i][j % ANGLES]=i;
  388.         for(j=k+ANGLES/2;j<k+ANGLES;j++)
  389.             LaneSel[i][j % ANGLES]=i-1;
  390.             
  391.         if(!(i & 7)) StarStep();
  392.     }
  393.     
  394.     
  395.     for(j=0;j<ANGLES;j++)
  396.         if(LaneSel[0][j]==-1)
  397.             LaneSel[0][j]=space->numsegs-1;
  398.  
  399.     StarStep();
  400.  
  401.     DoZapRecharge(0);                /* (mz) */
  402.     
  403.     for(j=k;j<k+ANGLES/2;j++)
  404.         LaneSel[space->numsegs][j % ANGLES]=0;
  405.  
  406.     StarStep();
  407.  
  408.     if(space->wraps==0)
  409.      {    PrevSeg[0]=-999;
  410.          NextSeg[space->numsegs]=-999;
  411.          for(j=0;j<ANGLES;j++)
  412.          {    LaneSel[0][j]=0;
  413.              LaneSel[space->numsegs][j]=space->numsegs-1;
  414.          }
  415.      }
  416.  
  417.     StarStep();
  418.     HUnlock(spacehand);
  419.     MakeSpots(&gridOutline);
  420.  
  421.     ReleaseResource(spacehand);
  422.     CloseStars();
  423. }
  424.  
  425. void    AllocGrids()
  426. {
  427.     register    int        *ip;
  428.     register    char    *cp;
  429.     register    int        i;
  430.     
  431.     ip=(int *)NewPtr(            (DEPTH-ZOOMDEPTH+1L)*sizeof(int)+
  432.                         MAXSEGS*(DEPTH-ZOOMDEPTH+1L)*sizeof(int)*4+
  433.                                  (MAXSEGS+1L)*ANGLES*sizeof(char));
  434.     for(i=0;i<MAXSEGS;i++)
  435.     {    ww.x[i]=ip-ZOOMDEPTH;        ip+=DEPTH-ZOOMDEPTH+1;
  436.         ww.y[i]=ip-ZOOMDEPTH;        ip+=DEPTH-ZOOMDEPTH+1;
  437.         ww.xc[i]=ip-ZOOMDEPTH;        ip+=DEPTH-ZOOMDEPTH+1;
  438.         ww.yc[i]=ip-ZOOMDEPTH;        ip+=DEPTH-ZOOMDEPTH+1;
  439.     }
  440.     ww.unitlen=ip-ZOOMDEPTH;
  441.     ip+=DEPTH-ZOOMDEPTH+1;
  442.  
  443.     cp=(char *)ip;
  444.     for(i=0;i<=MAXSEGS;i++)
  445.     {    LaneSel[i]=cp;    cp+=ANGLES;
  446.     }
  447. }